package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.cache.GuiGuCache;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.service.KafkaService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.Date;
import java.util.List;

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;
	@Autowired
	private AlbumAttributeValueMapper albumAttributeValueMapper;
	@Autowired
	private AlbumStatMapper albumStatMapper;
	@Autowired
	private KafkaService kafkaService;
	@Autowired
	private TrackInfoMapper trackInfoMapper;
	@Override
	@GuiGuCache(prefix = RedisConstant.ALBUM_INFO_PREFIX)
	public AlbumInfo getAlbumInfoById(Integer id) {
		AlbumInfo albumInfo = albumInfoMapper.getAlbumInfoById(id);
		if(albumInfo!=null){
			List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
		}
		return  albumInfo;
	}

	@Override
	public void updateStat(Long albumId, String statType, Integer count) {
		albumInfoMapper.updateStat(albumId, statType, count);
	}

	@Override
	public List<Long> getTrackByAlbumId(Long albumId, Long userId) {
		List<Long> list=trackInfoMapper.selectTrackByAlbumId(albumId,userId);
		return list;
	}

	@Override
	public List<AlbumInfo> findUserAllAlbumList(Long userId) {
		Page<AlbumInfo> albumInfoPage = new Page<>(1,100);
		LambdaQueryWrapper<AlbumInfo> wrapper = new LambdaQueryWrapper<>();
		wrapper.select(AlbumInfo::getId,AlbumInfo::getAlbumTitle);
		wrapper.eq(AlbumInfo::getUserId,userId);
		wrapper.orderByDesc(AlbumInfo::getId);

		return albumInfoMapper.selectPage(albumInfoPage,wrapper).getRecords();
	}

	@Override
	public List<AlbumAttributeValue> findAlbumAttributeValue(Long albumId) {
		LambdaQueryWrapper<AlbumAttributeValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId,albumId);
		List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(lambdaQueryWrapper);
		//	返回集合数据
		return albumAttributeValueList;
	}

	@Override
	@GuiGuCache(prefix =  "albumStat:")
	public AlbumStatVo getAlbumStatVo(Long albumId) {
		return albumInfoMapper.getAlbumStatVo(albumId);
	}

	@Override
	public IPage<AlbumListVo> findUserAlbumPage(Page<AlbumListVo> page1, AlbumInfoQuery albumInfoQuery) {

		return albumInfoMapper.findUserAlbumPage(page1,albumInfoQuery);
	}

	@Override
	public void removeAlbumInfo(Long id) {
		albumInfoMapper.deleteById(id);
		QueryWrapper<AlbumAttributeValue> queryWrapper=new QueryWrapper<>();
		queryWrapper.eq("album_id",id);
		albumAttributeValueMapper.delete(queryWrapper);
		LambdaQueryWrapper<AlbumStat> lambdaQueryWrapper=new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumStat::getAlbumId,id);
		albumStatMapper.delete(lambdaQueryWrapper);
	}

	@Override
	public void updateAlbumInfo(Integer id,AlbumInfoVo albumInfo) {
		AlbumInfo albumInfo1=new AlbumInfo();
		BeanUtils.copyProperties(albumInfo,albumInfo1);
		LambdaUpdateWrapper<AlbumInfo> lambdaUpdateWrapper=new LambdaUpdateWrapper<>();
		if (albumInfo.getAlbumTitle()!=null&&albumInfo.getAlbumTitle()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getAlbumTitle,albumInfo.getAlbumTitle());
		if (albumInfo.getCategory3Id()!=null&&albumInfo.getCategory3Id()!=0)
			lambdaUpdateWrapper.set(AlbumInfo::getCategory3Id,albumInfo.getCategory3Id());
		if (albumInfo.getAlbumIntro()!=null&&albumInfo.getAlbumIntro()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getAlbumIntro,albumInfo.getAlbumIntro());
		if (albumInfo.getCoverUrl()!=null&&albumInfo.getCoverUrl()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getCoverUrl,albumInfo.getCoverUrl());
		if (albumInfo.getEstimatedTrackCount()!=null&&albumInfo.getEstimatedTrackCount()!=0)
			lambdaUpdateWrapper.set(AlbumInfo::getEstimatedTrackCount,albumInfo.getEstimatedTrackCount());
		if (albumInfo.getAlbumRichIntro()!=null&&albumInfo.getAlbumRichIntro()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getAlbumRichIntro,albumInfo.getAlbumRichIntro());
		if (albumInfo.getPayType()!=null&&albumInfo.getPayType()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getPayType,albumInfo.getPayType());
		if (albumInfo.getPriceType()!=null&&albumInfo.getPayType()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getPayType,albumInfo.getPayType());
		if (albumInfo.getPrice()!=null&&!albumInfo.getPrice().equals(0))
			lambdaUpdateWrapper.set(AlbumInfo::getPrice,albumInfo.getPrice());
		if (albumInfo.getDiscount()!=null&&!albumInfo.getDiscount().equals(0))
			lambdaUpdateWrapper.set(AlbumInfo::getDiscount,albumInfo.getDiscount());
		if (albumInfo.getVipDiscount()!=null&&!albumInfo.getVipDiscount().equals(0))
			lambdaUpdateWrapper.set(AlbumInfo::getVipDiscount,albumInfo.getVipDiscount());
		if (albumInfo.getTracksForFree()!=null&&albumInfo.getTracksForFree()!=0)
			lambdaUpdateWrapper.set(AlbumInfo::getTracksForFree,albumInfo.getTracksForFree());
		if (albumInfo.getSecondsForFree()!=null&&albumInfo.getSecondsForFree()!=0)
			lambdaUpdateWrapper.set(AlbumInfo::getSecondsForFree,albumInfo.getSecondsForFree());
		if (albumInfo.getBuyNotes()!=null&&albumInfo.getBuyNotes()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getBuyNotes,albumInfo.getBuyNotes());
		if (albumInfo.getSellingPoint()!=null&&albumInfo.getSellingPoint()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getSellingPoint,albumInfo.getSellingPoint());
		if (albumInfo.getIsOpen()!=null&&albumInfo.getIsOpen()!="")
			lambdaUpdateWrapper.set(AlbumInfo::getIsOpen,albumInfo.getIsOpen());
		lambdaUpdateWrapper.set(AlbumInfo::getUpdateTime,new Date());
//		if (albumInfo.getPayTypeAndPrice()!=null&&albumInfo.getPayTypeAndPrice()!="")
//			lambdaUpdateWrapper.set(AlbumInfo::getPayTypeAndPrice,albumInfo.getPayTypeAndPrice());
//		if (albumInfo.getTracksForFree()!=null&&albumInfo.getTracksForFree()!=0)
//			lambdaUpdateWrapper.set(AlbumInfo::getTracksForFree,albumInfo.getTracksForFree());
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId,id));
		if(albumInfo.getAlbumAttributeValueVoList()!=null){
			for (AlbumAttributeValueVo albumAttributeValueVo : albumInfo.getAlbumAttributeValueVoList()) {
				AlbumAttributeValue albumAttributeValue=new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				albumAttributeValue.setUpdateTime(new Date());
//				LambdaUpdateWrapper<AlbumAttributeValue> lambdaUpdateWrapper1=new LambdaUpdateWrapper<>();
//				lambdaUpdateWrapper1.eq(AlbumAttributeValue::getAlbumId,id);
//				if (albumAttributeValueVo.getAttributeId()!=null&&albumAttributeValueVo.getAttributeId()!=0)
//					lambdaUpdateWrapper1.set(AlbumAttributeValue::getAttributeId,albumAttributeValueVo.getAttributeId());
//				if (albumAttributeValueVo.getValueId()!=null&&albumAttributeValueVo.getValueId()!=0)
//					lambdaUpdateWrapper1.set(AlbumAttributeValue::getValueId,albumAttributeValueVo.getValueId());
//				lambdaUpdateWrapper1.set(AlbumAttributeValue::getUpdateTime,new Date());
				albumAttributeValueMapper.insert(albumAttributeValue);
			}

		}


		lambdaUpdateWrapper.eq(AlbumInfo::getId,id);
		albumInfoMapper.update(albumInfo1,lambdaUpdateWrapper);
		if("1".equals(albumInfo.getIsOpen())) {
			kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_UPPER, String.valueOf(albumInfo1.getId()));
		} else {
			kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_LOWER, String.valueOf(albumInfo1.getId()));
		}
	}

	@Override
	@Transactional
	public void saveAll(AlbumInfoVo albumInfoVo,Long userId) {
		AlbumInfo albumInfo=new AlbumInfo();
		BeanUtils.copyProperties(albumInfoVo,albumInfo);
		albumInfo.setUserId(userId);
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
		if(!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())) {
			albumInfo.setTracksForFree(5);
		}
		albumInfoMapper.insert(albumInfo);
		if (!CollectionUtils.isEmpty(albumInfoVo.getAlbumAttributeValueVoList())){
			for (AlbumAttributeValueVo albumAttributeValueVo : albumInfoVo.getAlbumAttributeValueVoList()) {
				AlbumAttributeValue albumAttributeValue=new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				albumAttributeValueMapper.insert(albumAttributeValue);

			}
		}
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_PLAY);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_SUBSCRIBE);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_BROWSE);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_COMMENT);
		//发送消息
		if ("1".equals(albumInfo.getIsOpen())){
			this.kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_UPPER,String.valueOf(albumInfo.getId()));
		}

	}

	private void saveAlbumStat(Long id, String albumStatPlay) {
		AlbumStat albumStat = new AlbumStat();
		albumStat.setAlbumId(id);
		albumStat.setStatType(albumStatPlay);
		albumStat.setStatNum(0);
		albumStatMapper.insert(albumStat);
	}
}
